/**
 * 模拟API服务
 * 提供本地模拟的API响应，用于前端开发和测试
 */

import { utils } from './config.js'

// 模拟用户数据
const mockUsers = [
  {
    id: 1,
    username: 'admin',
    password: '123456',
    email: 'admin@example.com',
    mobile: '13800138000',
    role: 'admin',
    avatar: '/static/images/avatar/default.png',
    status: 1,
    createTime: '2023-01-01 00:00:00'
  },
  {
    id: 2,
    username: 'test',
    password: '123456',
    email: 'test@example.com',
    mobile: '13900139000',
    role: 'user',
    avatar: '/static/images/avatar/default.png',
    status: 1,
    createTime: '2023-01-02 00:00:00'
  }
]

// 模拟令牌
const mockTokens = {
  'admin': 'mock-token-admin-12345',
  'test': 'mock-token-test-67890'
}

/**
 * 生成随机ID
 * @returns {Number} 随机ID
 */
function generateId() {
  return Math.floor(Math.random() * 10000) + 100
}

/**
 * 生成模拟令牌
 * @param {String} username 用户名
 * @returns {String} 令牌
 */
function generateToken(username) {
  return `mock-token-${username}-${Math.random().toString(36).substring(2, 10)}`
}

/**
 * 模拟延迟
 * @param {Number} ms 延迟毫秒数
 * @returns {Promise} Promise对象
 */
function delay(ms = 300) {
  return new Promise(resolve => setTimeout(resolve, ms))
}

/**
 * 模拟API响应
 * @param {Object} data 响应数据
 * @param {Number} code 响应码
 * @param {String} message 响应消息
 * @returns {Object} 响应对象
 */
function mockResponse(data = null, code = 200, message = 'success') {
  return {
    code,
    message,
    data,
    timestamp: new Date().getTime()
  }
}

/**
 * 模拟API错误
 * @param {String} message 错误消息
 * @param {Number} code 错误码
 * @returns {Object} 错误响应对象
 */
function mockError(message = 'error', code = 500) {
  return mockResponse(null, code, message)
}

// 模拟API服务
const mockAPI = {
  /**
   * 是否启用模拟API
   */
  enabled: true,

  /**
   * 模拟延迟时间（毫秒）
   */
  delay: 300,

  /**
   * 初始化模拟API
   */
  init() {
    utils.log('info', '模拟API服务已初始化')
    this.enabled = true
  },

  /**
   * 处理请求
   * @param {String} url 请求URL
   * @param {String} method 请求方法
   * @param {Object} data 请求数据
   * @returns {Promise} Promise对象
   */
  async handleRequest(url, method, data) {
    if (!this.enabled) {
      return Promise.reject(new Error('模拟API服务未启用'))
    }

    // 记录请求
    utils.log('debug', `模拟API请求: ${method} ${url}`, data)

    // 模拟网络延迟
    await delay(this.delay)

    // 根据URL和方法处理不同的请求
    if (url.includes('/user/register') && method === 'POST') {
      return this.handleRegister(data)
    } else if (url.includes('/asurada/api/login') && method === 'POST') {
      return this.handleLogin(data)
    } else if (url.includes('/asurada/api/logout') && method === 'POST') {
      return this.handleLogout()
    } else if (url.includes('/asurada/api/user') && method === 'GET') {
      return this.handleGetUserInfo(data)
    } else if (url.includes('/asurada/api/status') && method === 'GET') {
      return this.handleCheckStatus()
    } else if (url.includes('/asurada/api/verify') && method === 'GET') {
      return this.handleVerifyToken()
    } else if (url.includes('/asurada/api/refresh') && method === 'POST') {
      return this.handleRefreshToken()
    } else if (url.includes('/asurada/api/sms') && method === 'POST') {
      return this.handleSendSms(data)
    } else if (url.includes('/asurada/api/verify-sms') && method === 'POST') {
      return this.handleVerifySms(data)
    }

    // 未匹配的请求返回404
    return Promise.reject(mockError('接口不存在', 404))
  },

  /**
   * 处理注册请求
   * @param {Object} data 注册数据
   * @returns {Promise} Promise对象
   */
  async handleRegister(data) {
    const { username, password, email, mobile } = data

    // 验证必填字段
    if (!username || !password || !email || !mobile) {
      return Promise.reject(mockError('请填写完整的注册信息', 400))
    }

    // 验证用户名格式
    if (!/^[a-zA-Z0-9_]{3,20}$/.test(username)) {
      return Promise.reject(mockError('用户名格式不正确', 400))
    }

    // 验证密码长度
    if (password.length < 6 || password.length > 20) {
      return Promise.reject(mockError('密码长度必须在6-20个字符之间', 400))
    }

    // 验证邮箱格式
    if (!/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(email)) {
      return Promise.reject(mockError('邮箱格式不正确', 400))
    }

    // 验证手机号格式
    if (!/^1[3-9]\d{9}$/.test(mobile)) {
      return Promise.reject(mockError('手机号格式不正确', 400))
    }

    // 检查用户名是否已存在
    const existingUser = mockUsers.find(user => user.username === username)
    if (existingUser) {
      return Promise.reject(mockError('用户名已存在', 400))
    }

    // 检查邮箱是否已存在
    const existingEmail = mockUsers.find(user => user.email === email)
    if (existingEmail) {
      return Promise.reject(mockError('邮箱已被注册', 400))
    }

    // 检查手机号是否已存在
    const existingMobile = mockUsers.find(user => user.mobile === mobile)
    if (existingMobile) {
      return Promise.reject(mockError('手机号已被注册', 400))
    }

    // 创建新用户
    const newUser = {
      id: generateId(),
      username,
      password,
      email,
      mobile,
      role: 'user',
      avatar: '/static/images/avatar/default.png',
      status: 1,
      createTime: new Date().toISOString().replace('T', ' ').substring(0, 19)
    }

    // 添加到用户列表
    mockUsers.push(newUser)

    // 生成令牌
    mockTokens[username] = generateToken(username)

    // 返回成功响应
    return mockResponse({
      token: mockTokens[username],
      user: {
        id: newUser.id,
        username: newUser.username,
        email: newUser.email,
        mobile: newUser.mobile,
        role: newUser.role,
        avatar: newUser.avatar
      }
    })
  },

  /**
   * 处理登录请求
   * @param {Object} data 登录数据
   * @returns {Promise} Promise对象
   */
  async handleLogin(data) {
    const { account, password } = data

    // 验证必填字段
    if (!account || !password) {
      return Promise.reject(mockError('请填写账号和密码', 400))
    }

    // 查找用户
    const user = mockUsers.find(user => 
      user.username === account || 
      user.email === account || 
      user.mobile === account
    )

    // 验证用户是否存在
    if (!user) {
      return Promise.reject(mockError('用户不存在', 400))
    }

    // 验证密码
    if (user.password !== password) {
      return Promise.reject(mockError('密码错误', 400))
    }

    // 生成或获取令牌
    const token = mockTokens[user.username] || generateToken(user.username)
    mockTokens[user.username] = token

    // 返回成功响应
    return mockResponse({
      token,
      user: {
        id: user.id,
        username: user.username,
        email: user.email,
        mobile: user.mobile,
        role: user.role,
        avatar: user.avatar
      }
    })
  },

  /**
   * 处理登出请求
   * @returns {Promise} Promise对象
   */
  async handleLogout() {
    return mockResponse(null)
  },

  /**
   * 处理获取用户信息请求
   * @returns {Promise} Promise对象
   */
  async handleGetUserInfo() {
    // 模拟已登录用户
    const user = mockUsers[0]

    return mockResponse({
      id: user.id,
      username: user.username,
      email: user.email,
      mobile: user.mobile,
      role: user.role,
      avatar: user.avatar
    })
  },

  /**
   * 处理检查登录状态请求
   * @returns {Promise} Promise对象
   */
  async handleCheckStatus() {
    return mockResponse({
      isLoggedIn: true
    })
  },

  /**
   * 处理验证令牌请求
   * @returns {Promise} Promise对象
   */
  async handleVerifyToken() {
    return mockResponse({
      valid: true
    })
  },

  /**
   * 处理刷新令牌请求
   * @returns {Promise} Promise对象
   */
  async handleRefreshToken() {
    // 模拟已登录用户
    const user = mockUsers[0]
    
    // 生成新令牌
    const newToken = generateToken(user.username)
    mockTokens[user.username] = newToken

    return mockResponse({
      token: newToken
    })
  },

  /**
   * 处理发送短信请求
   * @param {Object} data 请求数据
   * @returns {Promise} Promise对象
   */
  async handleSendSms(data) {
    const { phone, type } = data

    // 验证手机号
    if (!phone || !/^1[3-9]\d{9}$/.test(phone)) {
      return Promise.reject(mockError('手机号格式不正确', 400))
    }

    // 验证类型
    if (!type || !['login', 'register', 'reset'].includes(type)) {
      return Promise.reject(mockError('验证码类型不正确', 400))
    }

    // 返回成功响应
    return mockResponse({
      code: '123456', // 模拟环境直接返回验证码
      expireTime: 300 // 过期时间（秒）
    })
  },

  /**
   * 处理验证短信验证码请求
   * @param {Object} data 请求数据
   * @returns {Promise} Promise对象
   */
  async handleVerifySms(data) {
    const { phone, code, type } = data

    // 验证手机号
    if (!phone || !/^1[3-9]\d{9}$/.test(phone)) {
      return Promise.reject(mockError('手机号格式不正确', 400))
    }

    // 验证验证码
    if (!code || code !== '123456') { // 模拟环境固定验证码
      return Promise.reject(mockError('验证码错误', 400))
    }

    // 验证类型
    if (!type || !['login', 'register', 'reset'].includes(type)) {
      return Promise.reject(mockError('验证码类型不正确', 400))
    }

    // 返回成功响应
    return mockResponse({
      valid: true
    })
  }
}

export default mockAPI